home *** CD-ROM | disk | FTP | other *** search
/ Hottest 6 / Hottest 6 (1996)(PDSoft)[!].iso / pdsoft / demo_library / 4465.lha / FGP238.LHA / FGP.c < prev    next >
C/C++ Source or Header  |  1995-06-15  |  44KB  |  1,697 lines
  1. /****************************************
  2.  * Fantasy Grand Prix $Revision: 2.38 $ *
  3.  *   © 1994 Simon Austin                *
  4.  ****************************************/
  5.  
  6. /* $Id: FGP.c,v 2.38 1995/06/15 23:07:52 simon Exp simon $ */
  7.  
  8. /* Includes */
  9.  
  10. #include <stdio.h>
  11. #include <string.h>
  12. #include <stdlib.h>
  13. #include <ctype.h>
  14. #include "FGP.h"
  15.  
  16. /* Variables */
  17.  
  18. /* Amiga versions string. Type "version FGP" to find the current version
  19.    of FGP in use */
  20. const char *ver = "$VER: FGP © S Austin $Revision: 2.38 $";
  21.  
  22. /* Lines to be output as appropriate */
  23. const char *verst = "FGP2 by S Austin, additional design by J Simpson.\n$Revision: 2.38 $ $Date: 1995/06/15 23:07:52 $.\n";
  24.  
  25. /* The "how to use FGP" error strings */
  26. const char *errs1 = "Usage: ";
  27. const char *errs2 = " <[-r[n]] [-t[n]] [-d[n]] [-c[n]] [-s[n]] [filename]>\n";
  28.  
  29. /* Points for positions 1-6 */
  30. const int  points[] = { 0, 10, 6, 4, 3, 2, 1 }; 
  31.  
  32. /* File pointer for scores.fgp2 */
  33. FILE *scores_file;
  34.  
  35. /* And the actual name (dependant on system) */
  36. #ifndef MSDOS
  37. char *scores_name = "scores.fgp2";
  38. #endif
  39.  
  40. #ifdef MSDOS
  41. char *scores_name = "scores.fgp";
  42. #endif
  43.  
  44. /* Strings to store the teams' names and owners, the names of the drivers,
  45.    chassis, engines and races. */
  46. char owner[MAXTEAM][100], teamname[MAXTEAM][100], name[DRIVERS][100],
  47.      first[DRIVERS][100], chassisn[CHASSIS][100], enginen[ENGINES][100];
  48.  
  49. /* Costs for chassis, engines and drivers */
  50. int  chassisc[CHASSIS], enginec[ENGINES], namec[DRIVERS];
  51.  
  52. /* Team details */
  53. int  driver1[MAXTEAM], driver2[MAXTEAM], driver3[MAXTEAM], 
  54.      chassis[MAXTEAM], engine[MAXTEAM], scores[MAXTEAM], thisrce[MAXTEAM]; 
  55.  
  56. /* Race details */
  57. int  grid[DRIVERS], position[DRIVERS], status[DRIVERS], warmup[DRIVERS]; 
  58.  
  59. /* Scores */
  60. int  topsixpts[DRIVERS], awardpts[DRIVERS], incgridpts[DRIVERS],
  61.      warmuppts[DRIVERS], racesc[DRIVERS], retirepts[DRIVERS],
  62.      noqualpts[DRIVERS], carscr[CHASSIS], engscr[ENGINES],
  63.      carpts[DRIVERS], engpts[DRIVERS]; 
  64.  
  65. /* Used to keep track of whose driving what */
  66. int  drcar[DRIVERS], dreng[DRIVERS];
  67.  
  68. /* The current number of teams, drivers and races */
  69. int  nteams, ndrivers, nraces;
  70.  
  71. /* The total number of competing drivers, chassis and engines */
  72. int  maxdrivers, maxchassis, maxengines;
  73.  
  74. /* The line we are currently reading in any particular file */
  75. int  line_no;
  76.  
  77. /* Used to store what the user has called FGP */
  78. char *ranwith;
  79.  
  80. /* File pointers for the files to be used */
  81. FILE *data_file, *teams_file, *drivers_file, *old_scores,
  82.      *chassis_file, *engine_file; 
  83.  
  84. /* String to store the name of the data file */
  85. char data_name[256];
  86.  
  87. /* Flags */
  88. int  eflags[ENGINES], cflags[CHASSIS];
  89.   
  90. /* Used in producing and re-reading scores files */
  91. int  exists_flag, racedrivers, old_grid, old_car, old_eng;
  92.  
  93. /* Used in calculating scores */
  94. int  pos, point, totwarm, filled, end, warm;
  95.  
  96. /* The finishing state and whether a driver was nominated */
  97. char state, nom;
  98.  
  99. /* Flags for which output the user wants */
  100. int  teams, normal, drive, cars, spread;
  101.  
  102. /* Flag used in testing a team's legality */
  103. int  team_legal;
  104.  
  105. /* Used in sorting the results */
  106. int  whichcar[DRIVERS], whicheng[DRIVERS]; 
  107. int  nominated, last; 
  108.  
  109. int  cartot[CHASSIS], engtot[ENGINES];  
  110. int  sflags[MAXTEAM];
  111. int  totalsc[DRIVERS];
  112. int  sp_pos[MAXTEAM][16]; 
  113. int  teamscores[MAXTEAM][16];
  114. int  driverscore[DRIVERS][16], drivertotal[DRIVERS];
  115. int  carrun[CHASSIS][16], engrun[ENGINES][16];
  116. char racenames[16][100];
  117.  
  118. /* Depending on which system is in use, the hard coded filenames to use */
  119. #ifndef MSDOS
  120. char *teams_name = "teams.fgp2", *drivers_name = "drivers.fgp2", 
  121.      *chassis_name = "chassis.fgp2", *engine_name = "engine.fgp2", 
  122.      *temp_name = ".tempscores";
  123. #endif
  124.  
  125. #ifdef MSDOS
  126. char *teams_name = "teams.fgp", *drivers_name = "drivers.fgp", 
  127.      *chassis_name = "chassis.fgp", *engine_name = "engine.fgp", 
  128.      *temp_name = "fgpscore.tmp";
  129. #endif
  130.  
  131. void disperr(char *);
  132. void errorinfile(char *, char *, int);
  133. void doubleerror(char *, char *, char *, int);
  134. int strcasencmp(char *, char *, int);
  135. int driver2no(char *);
  136. int chassis2no(char *);
  137. int engine2no(char *);
  138. void capitalise(char *);
  139. unsigned int readline(char *, int, FILE *);
  140. void cleararrays(void);
  141. FILE *openfile(char *, char *);
  142. int checkinput(char *, int);
  143. int teamcost(int, int, int, int, int);
  144. void raceoutput(void);
  145. void teamoutput(void);
  146. void drivoutput(void);
  147. void carsoutput(void);
  148. void sprdoutput(void);
  149.   
  150. int main(int argc, char *argv[])
  151. { 
  152.   /* store is a temporary input buffer and racename the name of the race
  153.      as given in the data file  */
  154.   char store[100], racename[100];
  155.  
  156.   /* racecheck is used when overwriting a previous scores file */
  157.   char racecheck[100];
  158.   
  159.   /* Loop variables */
  160.   register int i, j, k;
  161.  
  162.   ranwith = argv[0];
  163.  
  164.   if(argc < 2 || argc > 7)
  165.   { 
  166.     /* Incorrect command line, display message and quit */
  167.     fputs(verst, stderr);
  168.     fputs(errs1, stderr);
  169.     fputs(argv[0], stderr);
  170.     fputs(errs2, stderr);
  171.     exit(0);
  172.   }
  173.   else
  174.   {   
  175.     /* clear output flags */
  176.     normal = 255;
  177.     teams = 255;
  178.     drive = 255;
  179.     cars = 255;
  180.     spread = 255;
  181.     
  182.     strcpy(data_name, "no_name");
  183.     
  184.     for(i = 1; i < argc; i+=1)
  185.     {
  186.       if(!strcasencmp(argv[i], "-r", 2))
  187.         normal = checkinput(argv[i], normal);
  188.       else if(!strcasencmp(argv[i], "-t", 2))
  189.         teams = checkinput(argv[i], teams);
  190.       else if(!strcasencmp(argv[i], "-d", 2))
  191.         drive = checkinput(argv[i], drive);
  192.       else if(!strcasencmp(argv[i], "-c", 2))
  193.         cars = checkinput(argv[i], cars);
  194.       else if(!strcasencmp(argv[i], "-s", 2))
  195.         spread = checkinput(argv[i], spread);
  196.       else
  197.       {
  198.         if(!strcmp(data_name, "no_name"))
  199.         {
  200.           /* Set data filename */
  201.           strcpy(data_name, argv[i]);
  202.         }
  203.         else
  204.         {
  205.           /* Incorrect command line, display message and quit */
  206.           fputs(verst, stderr);
  207.           fputs(errs1, stderr);
  208.           fputs(ranwith, stderr);
  209.           fputs(errs2, stderr);
  210.           exit(0);
  211.         }
  212.       }
  213.     }  
  214.   }
  215.  
  216.   cleararrays();
  217.  
  218.   for(i = 0; i <= MAXTEAM; i+=1)
  219.   {
  220.     scores[i] = 0;
  221.   }
  222.  
  223.   /* Read in chassis names */
  224.   chassis_file = openfile(chassis_name, "r");
  225.   line_no = 0;
  226.   
  227.   i=1;
  228.   readline(store, INLEN, chassis_file);
  229.   while(i < CHASSIS && !feof(chassis_file))
  230.   {
  231.     strcpy(chassisn[i], store);
  232.     readline(store, INLEN, chassis_file);
  233.     chassisc[i] = atoi(store);
  234.     readline(store, INLEN, chassis_file);
  235.     i+=1;
  236.   }
  237.   maxchassis = i-1;
  238.   
  239.   fclose(chassis_file);
  240.   
  241.   /* Read in engines names */
  242.   engine_file = openfile(engine_name, "r");
  243.   line_no = 0;
  244.   
  245.   i=1;
  246.   readline(store, INLEN, engine_file);
  247.   while(i < ENGINES && !feof(engine_file))
  248.   {
  249.     strcpy(enginen[i], store);
  250.     readline(store, INLEN, engine_file);
  251.     enginec[i] = atoi(store);
  252.     readline(store, INLEN, engine_file);
  253.     i+=1;
  254.   }
  255.   maxengines = i-1;
  256.  
  257.   fclose(engine_file);
  258.  
  259.   /* Read in driver details */
  260.   drivers_file = openfile(drivers_name, "r");
  261.   line_no = 0;
  262.   
  263.   i=1;
  264.   readline(store, INLEN, drivers_file);
  265.   while(i <= DRIVERS && !feof(drivers_file))
  266.   {
  267.     strcpy(name[i], store);
  268.     readline(store, INLEN, drivers_file);
  269.     strcpy(first[i], store);
  270.     readline(store, INLEN, drivers_file);
  271.     whichcar[i] = chassis2no(store);
  272.     if(whichcar[i] == 0)
  273.     {
  274.       doubleerror(drivers_name, "Unknown chassis", store, line_no);
  275.       fclose(drivers_file);
  276.       exit(0);
  277.     }
  278.     readline(store, INLEN, drivers_file);
  279.     whicheng[i] = engine2no(store);
  280.     if(whicheng[i] == 0)
  281.     {
  282.       doubleerror(drivers_name, "Unknown engine", store, line_no);
  283.       fclose(drivers_file);
  284.       exit(0);
  285.     }
  286.     readline(store, INLEN, drivers_file);
  287.     namec[i] = atoi(store);
  288.     readline(store, INLEN, drivers_file);
  289.     i+=1;
  290.   }
  291.   maxdrivers = i-1;
  292.   
  293.   fclose(drivers_file);
  294.     
  295.   /* Open teams.fgp2 */
  296.   teams_file = openfile(teams_name, "r");
  297.   line_no = 0;
  298.  
  299.   /* Get the number of teams competing */
  300.   readline(store, INLEN, teams_file);
  301.   nteams = atoi(store);
  302.  
  303.   for(i = 1; i < nteams + 1; i+=1)
  304.   {
  305.     readline(store, INLEN, teams_file); 
  306.     strcpy(owner[i], store);
  307.     readline(store, INLEN, teams_file);
  308.     strcpy(teamname[i], store);
  309.     readline(store, INLEN, teams_file);
  310.     driver1[i] = driver2no(store);
  311.     if(driver1[i] == 0)
  312.     {
  313.       doubleerror(teams_name, "Unknown driver", store, line_no);
  314.       fclose(teams_file);
  315.       exit(0);
  316.     }
  317.     readline(store, INLEN, teams_file);
  318.     driver2[i] = driver2no(store);
  319.     if(driver2[i] == 0)
  320.     {
  321.       doubleerror(teams_name, "Unknown driver", store, line_no);
  322.       fclose(teams_file);
  323.       exit(0);
  324.     }
  325.     readline(store, INLEN, teams_file);
  326.     driver3[i] = driver2no(store);
  327.     if(driver3[i] == 0)
  328.     {
  329.       doubleerror(teams_name, "Unknown driver", store, line_no);
  330.       fclose(teams_file);
  331.       exit(0);
  332.     }
  333.     readline(store, INLEN, teams_file);
  334.     chassis[i] = chassis2no(store);
  335.     if(chassis[i] == 0)
  336.     {
  337.       doubleerror(teams_name, "Unknown chassis", store, line_no);
  338.       fclose(teams_file);
  339.       exit(0);
  340.     }
  341.     readline(store, INLEN, teams_file);
  342.     engine[i] = engine2no(store);
  343.     if(engine[i] == 0)
  344.     {
  345.       doubleerror(teams_name, "Unknown engine", store, line_no);
  346.       fclose(teams_file);
  347.       exit(0);
  348.     }
  349.   }
  350.  
  351.   fclose(teams_file);
  352.  
  353.   /* Check that all teams are legal... */
  354.   team_legal = 0;
  355.   for(i = 1; i <= nteams; i+=1)
  356.   {
  357.     if(teamcost(driver1[i], driver2[i], driver3[i], chassis[i], engine[i]) > 30)
  358.     {
  359.       printf("%s owned by %s costs over £30m.\n", teamname[i], owner[i]);
  360.       team_legal = 1;
  361.     }
  362.     if(namec[driver3[i]] != 1)
  363.     {
  364.       printf("%s owned by %s has an illegal test driver.\n", teamname[i], owner[i]);
  365.       team_legal = 1;
  366.     }
  367.   }
  368.   
  369.   if(team_legal > 0)
  370.   {
  371.     exit(0);
  372.   }
  373.  
  374.   if(strcmp(data_name, "no_name") != 0)
  375.   {
  376.     /* Get details from data file */
  377.     data_file = openfile(data_name, "r");
  378.     line_no = 0;
  379.     /* read in name of race */
  380.     readline(racename, INLEN, data_file);
  381.  
  382.     i = 0;
  383.     totwarm = 0;
  384.     nominated = 0;
  385.     readline(store, INLEN, data_file);
  386.     
  387.     if(driver2no(racename) != 0 && driver2no(store) == 0)
  388.     {
  389.       errorinfile(data_name, "The race's name is missing", line_no-1);
  390.       exit(0);
  391.     }
  392.  
  393.     do
  394.     {
  395.       i+=1;
  396.       grid[i] = driver2no(store);
  397.       if(grid[i] == 0)
  398.       {
  399.         doubleerror(data_name, "Unknown driver", store, line_no);
  400.         exit(0);
  401.       }
  402.       drcar[i] = whichcar[grid[i]];
  403.       dreng[i] = whicheng[grid[i]];
  404.      
  405.       /* Check finished/retired/DNQ/dis-qualified flag */
  406.       readline(store, INLEN, data_file);
  407.       sscanf(store, "%c %d %d %c", &state, &end, &warm, &nom);
  408.      
  409.       state = tolower(state);
  410.       status[i] = 5;
  411.       if(state == 'd')
  412.         status[i] = 0;
  413.       if(state == 'f')
  414.         status[i] = 1;
  415.       if(state == 'r')
  416.         status[i] = 2;
  417.       if(state == 'n')
  418.         status[i] = 3;
  419.       if(state == 't')
  420.         status[i] = 4;
  421.       if(status[i] == 5)
  422.       {
  423.         errorinfile(data_name, "Flag not one of FRDNT", line_no);
  424.         exit(0);
  425.       }
  426.   
  427.       /* Get final position */
  428.       if(end < 0 || end > 26)
  429.       {
  430.         errorinfile(data_name, "Illegal finishing position", line_no);
  431.         exit(0);
  432.       }
  433.       position[i] = end;
  434.       if(status[i] >= 0 && status[i] <= 2 && position[i] == 0)
  435.       {
  436.         errorinfile(data_name, "Illegal finishing position", line_no);
  437.         exit(0);
  438.       }
  439.       if(i > 1)
  440.         for(k = 1; k < i; k+=1)
  441.           if(position[k] == end && end != 0)
  442.           {
  443.             errorinfile(data_name, "Final position already allocated", line_no);
  444.             exit(0);
  445.           }
  446.   
  447.       /* Warmup positions */
  448.       if(warm < 0 || warm > 26)
  449.       {
  450.         errorinfile(data_name, "Illegal warmup position", line_no);
  451.         exit(0);
  452.       }
  453.       warmup[i] = warm;
  454.       if(warm != 0 && status[i] != 0)
  455.         totwarm+=1;
  456.               
  457.       if(nom == '+')
  458.       {
  459.         if(nom == '+' && nominated == 0)
  460.           nominated = grid[i];
  461.         else
  462.         {
  463.           errorinfile(data_name, "Too many nominated drivers", line_no);
  464.           exit(0);
  465.         }
  466.         nom = '-';
  467.       }
  468.       
  469.       readline(store, INLEN, data_file);
  470.       
  471.     }
  472.     while(!feof(data_file));
  473.   
  474.     ndrivers = i;
  475.     fclose(data_file);
  476.  
  477.     /* find position of last driver (usually 26) */
  478.     last = 0;
  479.     for(i = 1; i < ndrivers+1; i+=1)
  480.       if(status[i] == 2)       /* if a driver retired */
  481.         if(position[i] > last) /* and has the highest position number */
  482.           last = position[i];  /* then he was in last place */
  483.     
  484.     filled = 0;
  485.     for(i = 1; i < ndrivers+1; i+=1)
  486.     {
  487.       if(position[i] <= last && (status[i] >= 0 && status[i] <= 2))
  488.         filled+=1;
  489.     }
  490.     if(filled != last)
  491.     {
  492.       fputs(verst, stderr);
  493.       fputs("Error in file \"", stderr);
  494.       fputs(data_name, stderr);
  495.       fputs("\". Unallocated result.\n", stderr);
  496.       exit(0);
  497.     }
  498.      
  499.     /* make sure that a maximum of six drivers score in the warmup */
  500.     if(totwarm > 6)
  501.       totwarm = 6;
  502.   
  503.     /* clear scores */
  504.     for(i = 0; i < DRIVERS; i+=1)
  505.     {
  506.       topsixpts[i] = 0;
  507.       awardpts[i] = 0;
  508.       incgridpts[i] = 0;
  509.       warmuppts[i] = 0;
  510.       retirepts[i] = 0;
  511.       noqualpts[i] = 0;
  512.       racesc[i] = 0;
  513.     }
  514.   
  515.     /* points for finishing in top six */
  516.     k = 1;
  517.     pos = 1;
  518.     point = 1;
  519.     do
  520.     {
  521.       while(position[k] != point)
  522.         k = k + 1;
  523.       if(status[k] == 1)
  524.       {
  525.         topsixpts[grid[k]] = 10 + points[pos];
  526.         pos+=1;
  527.       }
  528.       point+=1;
  529.       k = 1;
  530.     }
  531.     while(pos < 7 && point <= ndrivers);
  532.  
  533.     /* points for increasing on grid position */
  534.     for(i = 1; i < ndrivers+1; i+=1) /* look through grid... */
  535.       if(status[i] == 1)             /* ...for drivers who finish... */
  536.         if(position[i] < i)          /* ...and beat their grid position */
  537.           incgridpts[grid[i]] = (i-position[i]);
  538.  
  539.     /* adjust grid position increase due to disqualifications */
  540.     for(i = 1; i < ndrivers+1; i+=1)    /* check all drivers for... */
  541.       if(status[i] == 0)                /* ...disqualification and... */
  542.         for(j = 1; j <ndrivers+1; j+=1) /* ...adjust the scores of... */
  543.           if(position[j] > position[i] && status[j] == 1 && position[j] <= j)
  544.             incgridpts[grid[j]]+=1;     /* ...those who finish after them */
  545.   
  546.     /* nominated driver points */
  547.     awardpts[nominated] = 5;
  548.  
  549.     /* points for first 6 places in Sunday warmup */
  550.     pos = 1;
  551.     point = 1;
  552.     i = 1;
  553.     do
  554.     {
  555.       while(warmup[i] != point) 
  556.         i+=1; /* if a driver came at position 'point' in the warmup */
  557.       if(status[i] == 1 || status[i] == 2 || status[i] == 4) /* and was not disqualified */
  558.       {
  559.         warmuppts[grid[i]] = 7 - pos;
  560.         pos+=1;
  561.       }
  562.       point+=1;
  563.       i = 1;
  564.     }
  565.     while(pos < totwarm+1 && point <= ndrivers);
  566.  
  567.     /* points for first 5 to retire */
  568.     for(i = 1; i < ndrivers+1; i+=1)
  569.     {
  570.       if(status[i] == 2)
  571.       {
  572.         if(position[i] == last)
  573.           retirepts[grid[i]] = 5;
  574.         if(position[i] == last-1)
  575.           retirepts[grid[i]] = 4;
  576.         if(position[i] == last-2)
  577.           retirepts[grid[i]] = 3;
  578.         if(position[i] == last-3)
  579.           retirepts[grid[i]] = 2;
  580.         if(position[i] == last-4)
  581.           retirepts[grid[i]] = 1;
  582.       }
  583.     }
  584.  
  585.     /* points for non-qualification */
  586.     for(i = 1; i < ndrivers+1; i+=1)
  587.       if(status[i] == 3)
  588.         noqualpts[grid[i]] = 5;
  589.       
  590.     /* move non-starters & non-qualifiers to end of results */
  591.     pos = last+1;
  592.     for(i = 1; i < ndrivers+1; i+=1)
  593.     {
  594.       if(status[i] == 3 || status[i] == 4)
  595.       {
  596.         position[i] = pos;
  597.         pos+=1;
  598.       }
  599.     }
  600.   
  601.     /* reset chassis/engine flags/scores */
  602.     for(i = 0; i < ENGINES; i+=1)
  603.     {
  604.       eflags[i] = 0;  
  605.       engscr[i] = 0;
  606.     }
  607.  
  608.     for(i = 0; i < CHASSIS; i+=1)
  609.     {
  610.       cflags[i] = 0;
  611.       carscr[i] = 0;  
  612.     }
  613.   
  614.     for(i = 0; i < DRIVERS; i+=1)
  615.     {
  616.       carpts[i] = 0;
  617.       engpts[i] = 0;
  618.     }
  619.   
  620.     pos = 1;
  621.     point = 1;
  622.     i = 1;
  623.     do
  624.     {
  625.       while(position[i] != point)
  626.         i+=1; /* find driver who finished in position 'point' */
  627.       if(cflags[drcar[i]] == 0 && status[i] == 1)
  628.       {
  629.         /* if car hasn't already scored and driver did finish award points */
  630.         carpts[i] = points[pos]+10;            /* Version 2 rules */
  631.         carscr[drcar[i]] += points[pos]+10;    /* Version 2 rules */
  632.         cflags[drcar[i]] = 1;
  633.         pos+=1;
  634.       }
  635.     point+=1;
  636.       i = 1;
  637.     }
  638.     while( pos < 7 && point <= ndrivers);
  639.  
  640.     pos = 1;
  641.     point = 1;
  642.     i = 1;
  643.     do
  644.     {
  645.       while(position[i] != point)
  646.         i+=1;
  647.       if(eflags[dreng[i]] == 0 && status[i] == 1)
  648.       {
  649.         engpts[i] = points[pos]+10;            /* Version 2 rules */
  650.         engscr[dreng[i]] += points[pos]+10;    /* Version 2 rules */
  651.         eflags[dreng[i]] = 1;
  652.         pos+=1;
  653.       }
  654.       point+=1;
  655.       i = 1;
  656.     }
  657.     while( pos < 7 && point <= ndrivers);
  658.  
  659.     /* reset chassis flags */
  660.     for(i = 0; i < CHASSIS; i+=1)
  661.     {  
  662.       cflags[i] = 0;
  663.     }
  664.  
  665.     pos = last;
  666.     point = last;
  667.     i = 1;
  668.     do
  669.     {
  670.       while(position[i] != point)
  671.         i+=1;
  672.       if(cflags[drcar[i]] == 0 && status[i] == 2)
  673.       {
  674.         carpts[i] = -(pos-(last-5));
  675.         carscr[drcar[i]] -= (pos-(last-5));
  676.         cflags[drcar[i]] = 1;
  677.         pos-=1;
  678.       }
  679.       point-=1;
  680.       i = 1;
  681.     }
  682.     while(pos > last-5 && point > 0);
  683.  
  684.     scores_file = fopen(scores_name, "r");
  685.     if(scores_file == 0)
  686.     {
  687.       /* No scores file: assume start of season and */
  688.       /* create the scores file for writing */
  689.       scores_file = openfile(scores_name, "w");
  690.       exists_flag = 0;
  691.     } 
  692.     else 
  693.     {
  694.       /* if it does exists, open a temporary file to move the scores to */
  695.       fclose(scores_file);
  696.       scores_file = openfile(temp_name, "w");
  697.       exists_flag = 1;
  698.       old_scores = openfile(scores_name, "r");
  699.     
  700.       /* get the original scores and move them to the temp file until we
  701.          find a race with the same name or the end of the file */
  702.       readline(racecheck, INLEN, old_scores);
  703.     
  704.       while(strcasencmp(racecheck, racename, 6) && !feof(old_scores))
  705.       {
  706.         readline(store, INLEN, old_scores);
  707.         racedrivers = atoi(store);
  708.         fprintf(scores_file, "%s\n", racecheck);
  709.         fprintf(scores_file, "%d\n", racedrivers);
  710.         for(i = 1; i <= racedrivers; i+=1)
  711.         {
  712.           fgets(store, INLEN, old_scores);
  713.           fputs(store, scores_file);
  714.         }
  715.         readline(racecheck, INLEN, old_scores);
  716.       }
  717.     
  718.       if(!feof(old_scores))
  719.       {
  720.         /* If we haven't reached the end-of-file compare the old results
  721.            with the new results */
  722.         readline(store, INLEN, old_scores);
  723.         racedrivers = atoi(store);
  724.         for(i = 1; i <= racedrivers; i+=1)
  725.         {
  726.           fscanf(old_scores, "%d %d %d", &old_grid, &old_car, &old_eng);
  727.           readline(store, INLEN, old_scores);
  728.           if(old_car != whichcar[old_grid])
  729.           {
  730.             /* a driver had a different car before - send a non-fatal
  731.                message explaining this */
  732.             printf("** %s's car has changed from %s to %s.\n", 
  733.               name[old_grid], chassisn[old_car], 
  734.               chassisn[whichcar[old_grid]]);
  735.           }
  736.           if(old_eng != whicheng[old_grid])
  737.           {
  738.             printf("** %s's engine has changed from %s to %s.\n", 
  739.               name[old_grid], enginen[old_eng], 
  740.               enginen[whicheng[old_grid]]);
  741.           }
  742.         }
  743.       }
  744.     }
  745.   
  746.     /* put the new scores in the correct file */
  747.     fprintf(scores_file, "%s\n", racename);
  748.     fprintf(scores_file, "%d\n", ndrivers);
  749.     for(i = 1; i <= ndrivers; i+=1)
  750.     {
  751.       fprintf(scores_file, "%d %d %d %d %d %d %d %d %d %d %d %d %d %d %d\n",
  752.         grid[i], drcar[i], dreng[i], position[i], status[i], 
  753.         topsixpts[grid[i]], awardpts[grid[i]], incgridpts[grid[i]],
  754.         warmuppts[grid[i]], retirepts[grid[i]], noqualpts[grid[i]],
  755.         carpts[i], carscr[drcar[i]], engpts[i], engscr[dreng[i]]);
  756.     }
  757.  
  758.     if(exists_flag == 1)
  759.     {
  760.       readline(racecheck, INLEN, old_scores);
  761.       while(!feof(old_scores))
  762.       {
  763.         fprintf(scores_file, "%s\n", racecheck);
  764.         readline(store, INLEN, old_scores);
  765.         racedrivers = atoi(store);
  766.         fprintf(scores_file, "%d\n", racedrivers);
  767.         for(i = 1; i <= racedrivers; i+=1)
  768.         {
  769.           fgets(store, INLEN, old_scores);
  770.           fputs(store, scores_file);
  771.         }
  772.         readline(racecheck, INLEN, old_scores);
  773.       }
  774.       fclose(old_scores);
  775.       if(unlink(scores_name) == -1)
  776.       {
  777.         fputs("Unable to delete \"",stderr);
  778.         fputs(scores_name, stderr);
  779.         fputs("\".\n", stderr);
  780.         exit(0);
  781.       }
  782.     }
  783.   
  784.     fclose(scores_file);
  785.   
  786.     if(exists_flag == 1)
  787.       if(rename(temp_name, scores_name) == -1)
  788.       {
  789.         fputs("Unable to rename \"", stderr);
  790.         fputs(temp_name, stderr);
  791.         fputs("\".\n", stderr);
  792.         exit(0);
  793.       }
  794.   }
  795.  
  796.   if(normal != 255)
  797.     raceoutput();
  798.  
  799.   if(teams != 255)
  800.     teamoutput();
  801.  
  802.   if(drive != 255)
  803.     drivoutput();
  804.  
  805.   if(cars != 255)
  806.     carsoutput();
  807.  
  808.   if(spread != 255)
  809.     sprdoutput();
  810.   
  811.   return(0);
  812. }
  813.  
  814. void disperr(char *file_name)
  815. {
  816.   fputs(verst, stderr);
  817.   fputs("Unable to open \"", stderr);
  818.   fputs(file_name, stderr);
  819.   fputs("\".\n", stderr);
  820.   return;
  821. }
  822.  
  823. void errorinfile(char *file_name, char *error, int line)
  824. {
  825.   fputs(verst, stderr);
  826.   fputs("Error in file \"", stderr);
  827.   fputs(file_name, stderr);
  828.   fputs("\" on line ", stderr);
  829.   fprintf(stderr, "%d", line);
  830.   fputs(". ", stderr);
  831.   fputs(error, stderr);
  832.   fputs(".\n", stderr);
  833.   return;
  834. }  
  835.  
  836. void doubleerror(char *file_name, char *error, char *problem, int line)
  837. {
  838.   fputs(verst, stderr);
  839.   fputs("Error in file \"", stderr);
  840.   fputs(file_name, stderr);
  841.   fputs("\" on line ", stderr);
  842.   fprintf(stderr, "%d", line);
  843.   fputs(". ", stderr);
  844.   fputs(error, stderr);
  845.   fputs(" \"", stderr);
  846.   fputs(problem, stderr);
  847.   fputs("\".\n", stderr);
  848.   return;
  849. }  
  850.  
  851. int strcasencmp(char *stringa, char *stringb, int testnum)
  852. {
  853.   register int n;
  854.   char string1[100], string2[100];
  855.   
  856.   strcpy(string1, stringa);
  857.   strcpy(string2, stringb);
  858.   
  859.   for(n = 0; n <= strlen(string1); n+=1)
  860.     string1[n] = tolower(string1[n]);
  861.   for(n = 0; n <= strlen(string2); n+=1)
  862.     string2[n] = tolower(string2[n]);
  863.     
  864.   return(strncmp(string1, string2, testnum));
  865. }
  866.  
  867. int driver2no(char *driname)
  868. {
  869.   register int n;
  870.  
  871.   n = 1; 
  872.   while((strcasencmp(name[n], driname, 6)) && n <= maxdrivers)
  873.     n+=1;
  874.     
  875.   if(n > maxdrivers)
  876.     n = 0;
  877.   
  878.   return(n);
  879. }
  880.  
  881. int chassis2no(char *chaname)
  882. {
  883.   register int n;
  884.   
  885.   n = 1;
  886.   while((strcasencmp(chassisn[n], chaname, 6)) && n <= maxchassis)
  887.     n+=1;
  888.   
  889.   if(n > maxchassis)
  890.   {
  891.     n=0;
  892.     if(!strcasencmp("<None>", chaname, 6) || !strcasencmp("None", chaname, 4))
  893.       n = -1;
  894.   }
  895.     
  896.   return(n);
  897. }
  898.   
  899. int engine2no(char *engname)
  900. {
  901.   register int n;
  902.   
  903.   n = 1;
  904.   while((strcasencmp(enginen[n], engname, 6)) && n <= maxengines)
  905.     n+=1;
  906.   
  907.   if(n > maxengines)
  908.   {
  909.     n=0;
  910.     if(!strcasencmp("<None>", engname, 6) || !strcasencmp("None", engname, 4))
  911.       n = -1;
  912.   }
  913.     
  914.   return(n);
  915. }
  916.   
  917. void capitalise(char *word)
  918. {
  919.   word[0] = toupper(word[0]);
  920.   return;
  921. }
  922.  
  923. unsigned int readline(char *in_string, int chars_2_read, FILE *file_pointer)
  924. {
  925.   char temp[100];
  926.   
  927.   fgets(temp, chars_2_read, file_pointer);
  928.   line_no += 1;
  929.   
  930.   while((strlen(temp) == 1 || (temp[0] == '#' && temp[1] == '#')) && !feof(file_pointer))
  931.   {
  932.     fgets(temp, chars_2_read, file_pointer);
  933.     line_no +=1;
  934.   }
  935.   
  936.   strcpy(in_string, temp);
  937.   in_string[strlen(in_string)-1] = 0;
  938.   
  939.   return(strlen(temp)-1);
  940. }
  941.  
  942. void cleararrays(void)
  943. {
  944.   register int n;
  945.   
  946.   for(n = 1; n < DRIVERS; n+=1)
  947.   {
  948.     grid[n] = 0;
  949.     position[n] = 0;
  950.     status[n] = 0;
  951.     drcar[n] = 0;
  952.     dreng[n] = 0;
  953.     warmup[n] = 0;
  954.     topsixpts[n] = 0;
  955.     awardpts[n] = 0;
  956.     incgridpts[n] = 0;
  957.     warmuppts[n] = 0;
  958.     retirepts[n] = 0;
  959.     noqualpts[n] = 0;
  960.     carpts[n] = 0;
  961.     engpts[n] = 0;
  962.     racesc[n] = 0;
  963.   }
  964.       
  965.   for(n = 0; n < CHASSIS; n+=1)
  966.   {
  967.     carscr[n] = 0;
  968.   }
  969.       
  970.   for(n = 0; n < ENGINES; n+=1)
  971.   {
  972.     engscr[n] = 0;
  973.   }
  974.   
  975.   return;
  976. }
  977.  
  978. FILE *openfile(char *filename, char *mode)
  979. {
  980.   FILE *filepointer;
  981.   
  982.   filepointer = fopen(filename, mode);
  983.   if(filepointer == 0)
  984.   {
  985.     disperr(filename);
  986.     exit(0);
  987.   }
  988.   
  989.   return(filepointer);
  990. }
  991.  
  992. int checkinput(char *argument, int check)
  993. {
  994.   if(check != 255)
  995.   {
  996.     /* Incorrect command line, display message and quit */
  997.     fputs(verst, stderr);
  998.     fputs(errs1, stderr);
  999.     fputs(ranwith, stderr);
  1000.     fputs(errs2, stderr);
  1001.     exit(0);
  1002.   }
  1003.   
  1004.   strncpy(argument, "00", 2);
  1005.   return(atoi(argument));
  1006. }
  1007.  
  1008. int teamcost(int dr1, int dr2, int dr3, int cha, int eng)
  1009. {
  1010.   return(namec[dr1]+namec[dr2]+namec[dr3]+chassisc[cha]+enginec[eng]);
  1011. }
  1012.  
  1013. int readscores(char *racename, char *store)
  1014. {
  1015.   register int i;
  1016.  
  1017.   strcpy(racename, store);
  1018.   readline(store, INLEN, scores_file);
  1019.   ndrivers = atoi(store);
  1020.      
  1021.   for(i = 1; i <= ndrivers; i+=1)
  1022.   {
  1023.     fscanf(scores_file, "%d %d %d", &grid[i], &drcar[i], &dreng[i]);
  1024.     fscanf(scores_file, " %d %d %d %d %d %d %d %d %d %d %d %d",
  1025.       &position[i], &status[i], &topsixpts[grid[i]], 
  1026.       &awardpts[grid[i]], &incgridpts[grid[i]], &warmuppts[grid[i]], 
  1027.       &retirepts[grid[i]], &noqualpts[grid[i]], &carpts[i], 
  1028.       &carscr[drcar[i]], &engpts[i], &engscr[dreng[i]]);
  1029.     fgets(store, INLEN, scores_file);
  1030.   }
  1031.   
  1032.   return(ndrivers);
  1033. }
  1034.  
  1035. void raceoutput(void)
  1036. {
  1037.   register int i,j,k;
  1038.   char code[4], fullname[100], racename[100], store[100];
  1039.   char equalsign[2];
  1040.   int  display_pos, pos;
  1041.   int  highest, highscore; 
  1042.   int  d1, d2, d3, ch, en, best_score, best_team[5];
  1043.   int  top_score, top_team[5];
  1044.   int  bot_score, bot_team[5];
  1045.   int  wrst_score, wrst_team[5];
  1046.   int  first_race;
  1047.   
  1048.   j = 0;
  1049.   if(normal == 0)
  1050.     normal = 255;
  1051.     
  1052.   scores_file = openfile(scores_name, "r");
  1053.     
  1054.   for(i = 0; i < CHASSIS; i+=1)
  1055.   {
  1056.     cartot[i] = 0;
  1057.   }
  1058.       
  1059.   for(i = 0; i < ENGINES; i+=1)
  1060.   {
  1061.     engtot[i] = 0;
  1062.   }
  1063.  
  1064.   for(i = 0; i <= MAXTEAM; i+=1)
  1065.   {
  1066.     scores[i] = 0;
  1067.   }
  1068.   
  1069.   for(i = 0; i <= DRIVERS; i+=1)
  1070.   {
  1071.     totalsc[i] = 0;
  1072.   }
  1073.  
  1074.   readline(store, INLEN, scores_file);
  1075.   while(j != normal && !feof(scores_file))
  1076.   {
  1077.     cleararrays();
  1078.      
  1079.     ndrivers = readscores(racename, store); 
  1080.  
  1081.     /* total up scores */
  1082.     for(k = 0; k < DRIVERS; k+=1)
  1083.     {
  1084.       racesc[k]=topsixpts[k]+awardpts[k]+incgridpts[k]+warmuppts[k]-
  1085.         retirepts[k]-noqualpts[k];
  1086.       totalsc[k]+=racesc[k];
  1087.     }
  1088.  
  1089.     for(k = 1; k <= maxchassis; k+=1)
  1090.       cartot[k] += carscr[k];
  1091.     
  1092.     for(k = 1; k <= maxengines; k+=1)
  1093.       engtot[k] += engscr[k];
  1094.  
  1095.     /* Calculate teams' scores */
  1096.     for(k = 1; k <= nteams; k+=1)
  1097.     {
  1098.       thisrce[k]=(racesc[driver1[k]]+racesc[driver2[k]]+
  1099.         racesc[driver3[k]]+carscr[chassis[k]]+engscr[engine[k]]);
  1100.       scores[k]+=thisrce[k];
  1101.     }
  1102.      
  1103.     j+=1;
  1104.     readline(store, INLEN, scores_file);
  1105.   }
  1106.   
  1107.   first_race = j;
  1108.   fclose(scores_file);
  1109.  
  1110.   best_score = -500;
  1111.   wrst_score = 500;
  1112.   top_score = -500;
  1113.   bot_score = 500;
  1114.   for(d1 = 1; d1 < maxdrivers+1; d1+=1)
  1115.     for(d2 = 1; d2 < maxdrivers+1; d2+=1)
  1116.       for(d3 = 1; d3 < maxdrivers+1; d3+=1)
  1117.         for(ch = 1; ch < maxchassis+1; ch+=1)
  1118.           for(en = 1; en < maxengines+1; en+=1)
  1119.             if(d1 != d2 && d1 != d3 && d2 != d3 && namec[d3] == 1)
  1120.               if(teamcost(d1, d2, d3, ch, en) <= 30)
  1121.               {
  1122.                 if(racesc[d1]+racesc[d2]+racesc[d3]+carscr[ch]+engscr[en]
  1123.                   > best_score)
  1124.                 {
  1125.                   best_score = racesc[d1]+racesc[d2]+racesc[d3]+carscr[ch]+engscr[en];
  1126.                   best_team[0] = d1;
  1127.                   best_team[1] = d2;
  1128.                   best_team[2] = d3;
  1129.                   best_team[3] = ch;
  1130.                   best_team[4] = en;
  1131.                 }
  1132.                 if(racesc[d1]+racesc[d2]+racesc[d3]+carscr[ch]+engscr[en]
  1133.                   < wrst_score)
  1134.                 {
  1135.                   wrst_score = racesc[d1]+racesc[d2]+racesc[d3]+carscr[ch]+engscr[en];
  1136.                   wrst_team[0] = d1;
  1137.                   wrst_team[1] = d2;
  1138.                   wrst_team[2] = d3;
  1139.                   wrst_team[3] = ch;
  1140.                   wrst_team[4] = en;
  1141.                 }
  1142.                 if(totalsc[d1]+totalsc[d2]+totalsc[d3]+cartot[ch]+engtot[en]
  1143.                   > top_score)
  1144.                 {
  1145.                   top_score = totalsc[d1]+totalsc[d2]+totalsc[d3]+cartot[ch]+engtot[en];
  1146.                   top_team[0] = d1;
  1147.                   top_team[1] = d2;
  1148.                   top_team[2] = d3;
  1149.                   top_team[3] = ch;
  1150.                   top_team[4] = en;
  1151.                 }
  1152.                 if(totalsc[d1]+totalsc[d2]+totalsc[d3]+cartot[ch]+engtot[en]
  1153.                   < bot_score)
  1154.                 {
  1155.                   bot_score = totalsc[d1]+totalsc[d2]+totalsc[d3]+cartot[ch]+engtot[en];
  1156.                   bot_team[0] = d1;
  1157.                   bot_team[1] = d2;
  1158.                   bot_team[2] = d3;
  1159.                   bot_team[3] = ch;
  1160.                   bot_team[4] = en;
  1161.                 }
  1162.               }
  1163.  
  1164.   printf("%s\n", verst);
  1165.   capitalise(racename);
  1166.   printf("%s Starting Grid\n\n", racename);
  1167.   for(i = 1; i < ndrivers+1; i+=1) 
  1168.   {
  1169.     if(status[i] != 3)
  1170.     {
  1171.       sprintf(fullname, "%s %s", first[grid[i]], name[grid[i]]);
  1172.       printf("%2d : %-30s", i, fullname);
  1173.       printf(" %s-", chassisn[drcar[i]]);
  1174.       printf("%s\n", enginen[dreng[i]]);
  1175.     } 
  1176.   }
  1177.   printf("\n%s Results\n\n", racename);
  1178.   printf("    NAME      POINTS BREAKDOWN       CHASSIS    POINTS ENGINE");
  1179.   printf("        POINTS\n");
  1180.   printf("                      Top Six\n");
  1181.   printf("                      |  Award                Driver's          ");
  1182.   printf("   Driver's\n");
  1183.   printf("                      |  | Grid Increase       Chassis          ");
  1184.   printf("     Engine\n");
  1185.   printf("                      |  | |  Warm-up               |           ");
  1186.   printf("         |\n");
  1187.   printf("                      |  | |  | Retirement          |           ");
  1188.   printf("         |\n");
  1189.   printf("                      |  | |  | | Non-qualification |           ");
  1190.   printf("         |\n");
  1191.   printf("                      |  | |  | | |                 |           ");
  1192.   printf("         |\n");
  1193.  
  1194.   pos = 1;
  1195.   j = 1;
  1196.   do
  1197.   {
  1198.     while(position[j] != pos)
  1199.       j+=1;
  1200.     if(status[j] == 0)
  1201.       strcpy(code, "DIS");
  1202.     if(status[j] == 1)
  1203.       sprintf(code, "%-3d", pos);
  1204.     if(status[j] == 2)
  1205.       strcpy(code, "rtd");
  1206.     if(status[j] == 3)
  1207.       strcpy(code, "DNQ");
  1208.     if(status[j] == 4)
  1209.       strcpy(code, "DNS");
  1210.         
  1211.     printf("%s %-13s %2d (%02d+%1d+%02d+%1d-%1d-%1d) ", code, name[grid[j]],
  1212.       racesc[grid[j]], topsixpts[grid[j]], awardpts[grid[j]], 
  1213.       incgridpts[grid[j]], warmuppts[grid[j]], retirepts[grid[j]],
  1214.       noqualpts[grid[j]]);
  1215.     printf("%-9s %2d [%2d]", 
  1216.       chassisn[drcar[j]], carscr[drcar[j]], carpts[j]);
  1217.     printf(" %-12s %2d [%2d]\n", 
  1218.       enginen[dreng[j]], engscr[dreng[j]], engpts[j]);
  1219.     pos+=1;
  1220.     j = 1;
  1221.   }
  1222.   while(pos < ndrivers+1); 
  1223.  
  1224.   for(i = 1; i < MAXTEAM; i+=1)
  1225.     sflags[i] = 0;
  1226.  
  1227.   printf("\n%s Scores Table\n\n", racename);
  1228.   for(i = 1; i < nteams+1; i+=1)
  1229.   {
  1230.     display_pos = 1;
  1231.     strcpy(equalsign, " ");
  1232.     highest = 0;
  1233.     highscore = -500;
  1234.     for(j = 1; j < nteams+1; j+=1)
  1235.       if(sflags[j] == 0)
  1236.         if(thisrce[j] > highscore)
  1237.         {
  1238.           highscore = thisrce[j];
  1239.           highest = j;
  1240.         }
  1241.     sflags[highest] = 1;
  1242.     for(j = 1; j < nteams+1; j+=1)
  1243.     {
  1244.       if(thisrce[j] > thisrce[highest])
  1245.         display_pos+=1;
  1246.       if(thisrce[j] == thisrce[highest] && j != highest)
  1247.         strcpy(equalsign, "=");
  1248.     }
  1249.     printf("%s%-3d %-25s %3d\n", equalsign, display_pos, teamname[highest],
  1250.       thisrce[highest]);
  1251.   }
  1252.  
  1253.   for(i = 1; i < MAXTEAM; i+=1)
  1254.     sflags[i] = 0;
  1255.  
  1256.   printf("\n%s Team Scores\n\n", racename);
  1257.   for(i = 1; i < nteams+1; i+=1)
  1258.   {
  1259.     display_pos = 1;
  1260.     strcpy(equalsign, " ");
  1261.     highest = 0;
  1262.     highscore = -500;
  1263.     for(j = 1; j < nteams+1; j+=1)
  1264.       if(sflags[j] == 0)
  1265.         if(scores[j] > highscore)
  1266.         {
  1267.           highscore = scores[j];
  1268.           highest = j;
  1269.         }
  1270.     sflags[highest] = 1;
  1271.     for(j = 1; j < nteams+1; j+=1)
  1272.     {
  1273.       if(scores[j] > scores[highest])
  1274.         display_pos+=1;
  1275.       if(scores[j] == scores[highest] && j != highest)
  1276.         strcpy(equalsign, "=");
  1277.     }  
  1278.     printf("Team Owner   : %s\nTeam Name    : %s\n", owner[highest],
  1279.       teamname[highest]);
  1280.     printf("Position     : %2d%s\n", display_pos, equalsign);
  1281.     printf("Series Score : %3d\n", scores[highest]); 
  1282.     printf("Race Score   : %3d\n", thisrce[highest]);
  1283.     printf("Race Details : Driver one    - %-13s = %2d\n", name[driver1[highest]], 
  1284.       racesc[driver1[highest]]);
  1285.     printf("               Driver two    - %-13s = %2d\n", name[driver2[highest]], 
  1286.       racesc[driver2[highest]]);
  1287.     printf("               Test driver   - %-13s = %2d\n", name[driver3[highest]], 
  1288.       racesc[driver3[highest]]);
  1289.     printf("               Car's chassis - %-13s = %2d\n", 
  1290.       chassisn[chassis[highest]], carscr[chassis[highest]]);
  1291.     printf("               Car's engine  - %-13s = %2d\n\n", 
  1292.       enginen[engine[highest]], engscr[engine[highest]]);
  1293.   }
  1294.   
  1295.   printf("\n\nThe highest possible score from this race was %d points by:\n", best_score);
  1296.   printf("Driver one  : %-13s %2d (£%dm)\n", name[best_team[0]],
  1297.     racesc[best_team[0]], namec[best_team[0]]);
  1298.   printf("Driver two  : %-13s %2d (£%dm)\n", name[best_team[1]],
  1299.     racesc[best_team[1]], namec[best_team[1]]);
  1300.   printf("Test driver : %-13s %2d (£%dm)\n", name[best_team[2]],
  1301.     racesc[best_team[2]], namec[best_team[2]]);
  1302.   printf("Chassis     : %-13s %2d (£%dm)\n", chassisn[best_team[3]],
  1303.     carscr[best_team[3]], chassisc[best_team[3]]);
  1304.   printf("Engine      : %-13s %2d (£%dm)\n", enginen[best_team[4]],
  1305.     engscr[best_team[4]], enginec[best_team[4]]);
  1306.   printf("This team cost £%dm.\n", teamcost(best_team[0], best_team[1],
  1307.     best_team[2], best_team[3], best_team[4]));
  1308.     
  1309.   printf("\nThe lowest possible score from this race was %d points by:\n", wrst_score);
  1310.   printf("Driver one  : %-13s %2d (£%dm)\n", name[wrst_team[0]],
  1311.     racesc[wrst_team[0]], namec[wrst_team[0]]);
  1312.   printf("Driver two  : %-13s %2d (£%dm)\n", name[wrst_team[1]],
  1313.     racesc[wrst_team[1]], namec[wrst_team[1]]);
  1314.   printf("Test driver : %-13s %2d (£%dm)\n", name[wrst_team[2]],
  1315.     racesc[wrst_team[2]], namec[wrst_team[2]]);
  1316.   printf("Chassis     : %-13s %2d (£%dm)\n", chassisn[wrst_team[3]],
  1317.     carscr[wrst_team[3]], chassisc[wrst_team[3]]);
  1318.   printf("Engine      : %-13s %2d (£%dm)\n", enginen[wrst_team[4]],
  1319.     engscr[wrst_team[4]], enginec[wrst_team[4]]);
  1320.   printf("This team cost £%dm.\n", teamcost(wrst_team[0], wrst_team[1],
  1321.     wrst_team[2], wrst_team[3], wrst_team[4]));
  1322.   
  1323.   if(first_race != 1)
  1324.   {
  1325.     printf("\nThe highest possible score so far is %d points by:\n", top_score);
  1326.     printf("Driver one  : %-13s %2d (£%dm)\n", name[top_team[0]],
  1327.       totalsc[top_team[0]], namec[top_team[0]]);
  1328.     printf("Driver two  : %-13s %2d (£%dm)\n", name[top_team[1]],
  1329.       totalsc[top_team[1]], namec[top_team[1]]);
  1330.     printf("Test driver : %-13s %2d (£%dm)\n", name[top_team[2]],
  1331.       totalsc[top_team[2]], namec[top_team[2]]);
  1332.     printf("Chassis     : %-13s %2d (£%dm)\n", chassisn[top_team[3]],
  1333.       cartot[top_team[3]], chassisc[top_team[3]]);
  1334.     printf("Engine      : %-13s %2d (£%dm)\n", enginen[top_team[4]],
  1335.       engtot[top_team[4]], enginec[top_team[4]]);
  1336.     printf("This team cost £%dm.\n", teamcost(top_team[0], top_team[1],
  1337.       top_team[2], top_team[3], top_team[4]));
  1338.     
  1339.     printf("\nThe lowest possible score so far is %d points by:\n", bot_score);
  1340.     printf("Driver one  : %-13s %2d (£%dm)\n", name[bot_team[0]],
  1341.       totalsc[bot_team[0]], namec[bot_team[0]]);
  1342.     printf("Driver two  : %-13s %2d (£%dm)\n", name[bot_team[1]],
  1343.       totalsc[bot_team[1]], namec[bot_team[1]]);
  1344.     printf("Test driver : %-13s %2d (£%dm)\n", name[bot_team[2]],
  1345.       totalsc[bot_team[2]], namec[bot_team[2]]);
  1346.     printf("Chassis     : %-13s %2d (£%dm)\n", chassisn[bot_team[3]],
  1347.       cartot[bot_team[3]], chassisc[bot_team[3]]);
  1348.     printf("Engine      : %-13s %2d (£%dm)\n", enginen[bot_team[4]],
  1349.       engtot[bot_team[4]], enginec[bot_team[4]]);
  1350.     printf("This team cost £%dm.\n\n", teamcost(bot_team[0], bot_team[1],
  1351.       bot_team[2], bot_team[3], bot_team[4]));
  1352.   }
  1353.   
  1354.   return;
  1355. }
  1356.  
  1357. void teamoutput(void)
  1358. {
  1359.   register int i,j,k;
  1360.   char store[100], dispname[21];
  1361.  
  1362.   j = 0;
  1363.   if(teams == 0)
  1364.     teams = 255;
  1365.   
  1366.   scores_file = openfile(scores_name, "r");
  1367.    
  1368.   for(i = 0; i <= MAXTEAM; i+=1)
  1369.   {
  1370.     scores[i] = 0;
  1371.   }
  1372.  
  1373.   readline(store, INLEN, scores_file);
  1374.   while(j != teams && !feof(scores_file))
  1375.   {
  1376.     cleararrays();
  1377.       
  1378.     ndrivers = readscores(racenames[j], store); 
  1379.  
  1380.     /* total up scores */
  1381.     for(k = 0; k < DRIVERS; k+=1)
  1382.       racesc[k]=topsixpts[k]+awardpts[k]+incgridpts[k]+warmuppts[k]-
  1383.         retirepts[k]-noqualpts[k];
  1384.  
  1385.     /* Calculate teams' scores */
  1386.     for(k = 1; k <= nteams; k+=1)
  1387.     {
  1388.       teamscores[k][j]=(racesc[driver1[k]]+racesc[driver2[k]]+
  1389.         racesc[driver3[k]]+carscr[chassis[k]]+engscr[engine[k]]);
  1390.       scores[k]+=teamscores[k][j];
  1391.     }
  1392.     
  1393.     j+=1;
  1394.     readline(store, INLEN, scores_file);
  1395.   }
  1396.   nraces = j-1;
  1397.    
  1398.   fclose(scores_file);
  1399.  
  1400.   printf("%s\n", verst);
  1401.   printf("Team scores table\n");
  1402.     
  1403.   for(i = 0; i <= nraces; i+=1)
  1404.   {
  1405.     printf("                        ");
  1406.     if(i > 0)
  1407.       for(j = 0; j < i; j+=1)
  1408.         printf(" |  ");
  1409.     printf("%s\n", racenames[i]);
  1410.   }
  1411.     
  1412.   printf("+----------------------+");
  1413.   for(i = 0; i <= nraces; i+=1)
  1414.     printf("---+");
  1415.   printf("-----+\n");
  1416.     
  1417.   for(i = 1; i <= nteams; i+=1)
  1418.   {
  1419.     strncpy(dispname, teamname[i], 20);
  1420.     dispname[20] = 0;
  1421.     printf("| %-20s |", dispname);
  1422.     for(j = 0; j <= nraces; j+=1)
  1423.       printf("%3d|", teamscores[i][j]);
  1424.     printf("%5d|\n", scores[i]);
  1425.    
  1426.     printf("+----------------------+");
  1427.     for(k = 0; k <= nraces; k+=1)
  1428.       printf("---+");
  1429.     printf("-----+\n");
  1430.   }
  1431.   printf("\n");
  1432.  
  1433.   return;
  1434. }
  1435.  
  1436. void drivoutput(void)
  1437. {
  1438.   register int i,j,k; 
  1439.   char store[100];
  1440.  
  1441.   j = 0;
  1442.   if(drive == 0)
  1443.     drive = 255;
  1444.   
  1445.   scores_file = openfile(scores_name, "r");
  1446.  
  1447.   readline(store, INLEN, scores_file);
  1448.   while(j != drive && !feof(scores_file))
  1449.   {
  1450.     cleararrays();
  1451.       
  1452.     ndrivers = readscores(racenames[j], store); 
  1453.  
  1454.     /* total up scores */
  1455.     for(k = 0; k < DRIVERS; k+=1)
  1456.     {
  1457.       driverscore[k][j]=topsixpts[k]+awardpts[k]+incgridpts[k]
  1458.         +warmuppts[k]-retirepts[k]-noqualpts[k];
  1459.       drivertotal[k]+=driverscore[k][j];
  1460.     }
  1461.       
  1462.     j+=1;
  1463.     readline(store, INLEN, scores_file);
  1464.   }
  1465.   nraces = j-1;
  1466.     
  1467.   fclose(scores_file);
  1468.  
  1469.   printf("%s\n", verst);
  1470.   printf("Driver scores table\n");
  1471.      
  1472.   for(i = 0; i <= nraces; i+=1)
  1473.   {
  1474.     printf("                        ");
  1475.     if(i > 0)
  1476.       for(j = 0; j < i; j+=1)
  1477.         printf(" |  ");
  1478.     printf("%s\n", racenames[i]);
  1479.   }
  1480.     
  1481.   printf("+----------------------+");
  1482.   for(i = 0; i <= nraces; i+=1)
  1483.     printf("---+");
  1484.   printf("-----+\n");
  1485.     
  1486.   for(i = 1; i <= maxdrivers; i+=1)
  1487.   {
  1488.     printf("| %-20s |", name[i]);
  1489.     for(j = 0; j <= nraces; j+=1)
  1490.       printf("%3d|", driverscore[i][j]);
  1491.     printf("%5d|\n", drivertotal[i]);
  1492.   
  1493.     printf("+----------------------+");
  1494.     for(k = 0; k <= nraces; k+=1)
  1495.       printf("---+");
  1496.     printf("-----+\n");
  1497.   }
  1498.   printf("\n");
  1499.  
  1500.   return;
  1501. }
  1502.  
  1503. void carsoutput(void)
  1504. {
  1505.   register int i,j,k;
  1506.   char store[100];
  1507.  
  1508.   j = 0;
  1509.   if(cars == 0)
  1510.     cars = 255;
  1511.     
  1512.   for(i = 0; i < CHASSIS; i+=1)
  1513.   {
  1514.     cartot[i] = 0;
  1515.   }
  1516.       
  1517.   for(i = 0; i < ENGINES; i+=1)
  1518.   {
  1519.     engtot[i] = 0;
  1520.   }
  1521.     
  1522.   scores_file = openfile(scores_name, "r");
  1523.  
  1524.   readline(store, INLEN, scores_file);
  1525.   while(j != cars && !feof(scores_file))
  1526.   {
  1527.     cleararrays();
  1528.       
  1529.     ndrivers = readscores(racenames[j], store); 
  1530.  
  1531.     for(k = 1; k <= maxchassis; k+=1)
  1532.     {
  1533.       carrun[k][j] = carscr[k];
  1534.       cartot[k] += carscr[k];
  1535.     }
  1536.     
  1537.     for(k = 1; k <= maxengines; k+=1)
  1538.     {
  1539.       engrun[k][j] = engscr[k];
  1540.       engtot[k] += engscr[k];
  1541.     }
  1542.       
  1543.     j+=1;
  1544.     readline(store, INLEN, scores_file);
  1545.   }
  1546.   nraces = j-1;
  1547.     
  1548.   fclose(scores_file);
  1549.  
  1550.   printf("%s\n", verst);
  1551.   printf("Chassis scores table\n");
  1552.      
  1553.   for(i = 0; i <= nraces; i+=1)
  1554.   {
  1555.     printf("                        ");
  1556.     if(i > 0)
  1557.       for(j = 0; j < i; j+=1)
  1558.         printf(" |  ");
  1559.     printf("%s\n", racenames[i]);
  1560.   }
  1561.     
  1562.   printf("+----------------------+");
  1563.   for(i = 0; i <= nraces; i+=1)
  1564.     printf("---+");
  1565.   printf("-----+\n");
  1566.    
  1567.   for(i = 1; i <= maxchassis; i+=1)
  1568.   {
  1569.     printf("| %-20s |", chassisn[i]);
  1570.     for(j = 0; j <= nraces; j+=1)
  1571.       printf("%3d|", carrun[i][j]);
  1572.     printf("%5d|\n", cartot[i]);
  1573.     
  1574.     printf("+----------------------+");
  1575.     for(k = 0; k <= nraces; k+=1)
  1576.       printf("---+");
  1577.     printf("-----+\n");
  1578.   }
  1579.   printf("\n");
  1580.  
  1581.   printf("Engine scores table\n");
  1582.      
  1583.   for(i = 0; i <= nraces; i+=1)
  1584.   {
  1585.     printf("                        ");
  1586.     if(i > 0)
  1587.       for(j = 0; j < i; j+=1)
  1588.         printf(" |  ");
  1589.     printf("%s\n", racenames[i]);
  1590.   }
  1591.    
  1592.   printf("+----------------------+");
  1593.   for(i = 0; i <= nraces; i+=1)
  1594.     printf("---+");
  1595.   printf("-----+\n");
  1596.    
  1597.   for(i = 1; i <= maxengines; i+=1)
  1598.   {
  1599.     printf("| %-20s |", enginen[i]);
  1600.     for(j = 0; j <= nraces; j+=1)
  1601.       printf("%3d|", engrun[i][j]);
  1602.     printf("%5d|\n", engtot[i]);
  1603.   
  1604.     printf("+----------------------+");
  1605.     for(k = 0; k <= nraces; k+=1)
  1606.       printf("---+");
  1607.     printf("-----+\n");
  1608.   }
  1609.   printf("\n");
  1610.   
  1611.   return;
  1612. }
  1613.  
  1614. void sprdoutput(void)
  1615. {
  1616.   register int i,j,k;
  1617.   char store[100];
  1618.  
  1619.   j = 0;
  1620.   if(spread == 0)
  1621.     spread = 255;
  1622.    
  1623.   scores_file = openfile(scores_name, "r");
  1624.     
  1625.   for(i = 0; i <= MAXTEAM; i+=1)
  1626.   {
  1627.     scores[i] = 0;
  1628.   }
  1629.  
  1630.   readline(store, INLEN, scores_file);
  1631.   while(j != spread && !feof(scores_file))
  1632.   {
  1633.     cleararrays();
  1634.      
  1635.     ndrivers = readscores(racenames[j], store); 
  1636.  
  1637.     /* total up scores */
  1638.     for(k = 0; k < DRIVERS; k+=1)
  1639.       racesc[k]=topsixpts[k]+awardpts[k]+incgridpts[k]+warmuppts[k]-
  1640.         retirepts[k]-noqualpts[k];
  1641.  
  1642.     /* Calculate teams' scores */
  1643.     for(k = 1; k <= nteams; k+=1)
  1644.     {
  1645.       teamscores[k][j]=(racesc[driver1[k]]+racesc[driver2[k]]+
  1646.         racesc[driver3[k]]+carscr[chassis[k]]+engscr[engine[k]]);
  1647.       if(j != 0)
  1648.         teamscores[k][j] = teamscores[k][j] + teamscores[k][j-1];
  1649.       scores[k]+=teamscores[k][j];
  1650.     }
  1651.      
  1652.     j+=1;
  1653.     readline(store, INLEN, scores_file);
  1654.   }
  1655.   nraces = j-1;
  1656.     
  1657.   fclose(scores_file);
  1658.  
  1659.   for(i = 0; i <= nraces; i+=1)
  1660.     printf(",%s", racenames[i]);
  1661.   printf("\n");
  1662.        
  1663.   for(i = 1; i <= nteams; i+=1)
  1664.   {
  1665.     printf("%s", teamname[i]);
  1666.     for(j = 0; j <= nraces; j+=1)
  1667.       printf(",%d", teamscores[i][j]);
  1668.     printf("\n"); 
  1669.   }
  1670.   printf("\n");
  1671.  
  1672.   for(i = 0; i <= MAXTEAM; i+=1)
  1673.     for(j = 0; j <= 16; j+=1)
  1674.       sp_pos[i][j] = 1;
  1675.  
  1676.   for(i = 0; i <= nraces; i+=1)
  1677.     printf(",%s", racenames[i]);
  1678.   printf("\n");
  1679.  
  1680.   for(i = 0; i <= nraces; i+=1)
  1681.     for(j = 1; j <= nteams; j+=1)
  1682.       for(k = 1; k <= nteams; k+=1)
  1683.         if(teamscores[k][i] > teamscores[j][i])
  1684.           sp_pos[j][i] = sp_pos[j][i] + 1;
  1685.     
  1686.   for(i = 1; i <= nteams; i+=1)
  1687.   {
  1688.     printf("%s", teamname[i]);
  1689.     for(j = 0; j <= nraces; j+=1)
  1690.       printf(",%d", sp_pos[i][j]);
  1691.     printf("\n");
  1692.   }
  1693.   
  1694.   return;
  1695. }
  1696.  
  1697.